// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.other.payables;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.OtherPayables;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(OtherPayables.class)
@Setter
@Getter
public class OtherPayablesSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "OtherPayables".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("feeSubmitter", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：OtherPayables/Allqt, OtherPayables/Unpaid, OtherPayables/PaidOff
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 其他应付单号(模糊搜索)
   */
  private String otherPayablesCode;

  /**
   * 其他应付单号 比较(eq)
   */
  private String otherPayablesCodeEq;
  /**
   * 其他应付单号 比较(neq)
   */
  private String otherPayablesCodeNeq;
  /**
   * 其他应付单号 比较(gt)
   */
  private String otherPayablesCodeGt;
  /**
   * 其他应付单号 比较(gte)
   */
  private String otherPayablesCodeGte;
  /**
   * 其他应付单号 比较(lt)
   */
  private String otherPayablesCodeLt;
  /**
   * 其他应付单号 比较(lte)
   */
  private String otherPayablesCodeLte;
  /**
   * 其他应付单号 比较(contains)
   */
  private String otherPayablesCodeContains;
  /**
   * 其他应付单号 比较(notcontains)
   */
  private String otherPayablesCodeNotcontains;
  /**
   * 其他应付单号 比较(startswith)
   */
  private String otherPayablesCodeStartswith;
  /**
   * 其他应付单号 比较(endswith)
   */
  private String otherPayablesCodeEndswith;
  /**
   * 其他应付单号 比较(isnull)
   */
  private Boolean otherPayablesCodeIsnull;
  /**
   * 其他应付单号 比较(isnotnull)
   */
  private Boolean otherPayablesCodeIsnotnull;

  /**
   * 其他应付单号(精确搜索)
   */
  private List<String> otherPayablesCodeInList;

  /**
   * 费用单号(模糊搜索)
   */
  private String feeCode;

  /**
   * 费用单号 比较(eq)
   */
  private String feeCodeEq;
  /**
   * 费用单号 比较(neq)
   */
  private String feeCodeNeq;
  /**
   * 费用单号 比较(gt)
   */
  private String feeCodeGt;
  /**
   * 费用单号 比较(gte)
   */
  private String feeCodeGte;
  /**
   * 费用单号 比较(lt)
   */
  private String feeCodeLt;
  /**
   * 费用单号 比较(lte)
   */
  private String feeCodeLte;
  /**
   * 费用单号 比较(contains)
   */
  private String feeCodeContains;
  /**
   * 费用单号 比较(notcontains)
   */
  private String feeCodeNotcontains;
  /**
   * 费用单号 比较(startswith)
   */
  private String feeCodeStartswith;
  /**
   * 费用单号 比较(endswith)
   */
  private String feeCodeEndswith;
  /**
   * 费用单号 比较(isnull)
   */
  private Boolean feeCodeIsnull;
  /**
   * 费用单号 比较(isnotnull)
   */
  private Boolean feeCodeIsnotnull;

  /**
   * 费用单号(精确搜索)
   */
  private List<String> feeCodeInList;

  /**
   * 应付对象(模糊搜索)
   */
  private String shouldObj;

  /**
   * 应付对象 比较(eq)
   */
  private String shouldObjEq;
  /**
   * 应付对象 比较(neq)
   */
  private String shouldObjNeq;
  /**
   * 应付对象 比较(gt)
   */
  private String shouldObjGt;
  /**
   * 应付对象 比较(gte)
   */
  private String shouldObjGte;
  /**
   * 应付对象 比较(lt)
   */
  private String shouldObjLt;
  /**
   * 应付对象 比较(lte)
   */
  private String shouldObjLte;
  /**
   * 应付对象 比较(contains)
   */
  private String shouldObjContains;
  /**
   * 应付对象 比较(notcontains)
   */
  private String shouldObjNotcontains;
  /**
   * 应付对象 比较(startswith)
   */
  private String shouldObjStartswith;
  /**
   * 应付对象 比较(endswith)
   */
  private String shouldObjEndswith;
  /**
   * 应付对象 比较(isnull)
   */
  private Boolean shouldObjIsnull;
  /**
   * 应付对象 比较(isnotnull)
   */
  private Boolean shouldObjIsnotnull;

  /**
   * 应付对象(精确搜索)
   */
  private List<String> shouldObjInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 应付费用类型
   */
  private String shouldFeeType;

  /**
   * 应付费用类型 比较(eq)
   */
  private String shouldFeeTypeEq;
  /**
   * 应付费用类型 比较(neq)
   */
  private String shouldFeeTypeNeq;
  /**
   * 应付费用类型 比较(gt)
   */
  private String shouldFeeTypeGt;
  /**
   * 应付费用类型 比较(gte)
   */
  private String shouldFeeTypeGte;
  /**
   * 应付费用类型 比较(lt)
   */
  private String shouldFeeTypeLt;
  /**
   * 应付费用类型 比较(lte)
   */
  private String shouldFeeTypeLte;
  /**
   * 应付费用类型 比较(contains)
   */
  private String shouldFeeTypeContains;
  /**
   * 应付费用类型 比较(notcontains)
   */
  private String shouldFeeTypeNotcontains;
  /**
   * 应付费用类型 比较(startswith)
   */
  private String shouldFeeTypeStartswith;
  /**
   * 应付费用类型 比较(endswith)
   */
  private String shouldFeeTypeEndswith;
  /**
   * 应付费用类型 比较(isnull)
   */
  private Boolean shouldFeeTypeIsnull;
  /**
   * 应付费用类型 比较(isnotnull)
   */
  private Boolean shouldFeeTypeIsnotnull;

  /**
   * 应付费用类型(精确搜索)
   */
  private List<String> shouldFeeTypeInList;

  /**
   * 应付金额
   */
  private java.math.BigDecimal shouldMoney;

  /**
   * 最小应付金额
   */
  private java.math.BigDecimal shouldMoneyMin;

  /**
   * 最大应付金额
   */
  private java.math.BigDecimal shouldMoneyMax;

  /**
   * 应付金额 比较(eq)
   */
  private java.math.BigDecimal shouldMoneyEq;
  /**
   * 应付金额 比较(neq)
   */
  private java.math.BigDecimal shouldMoneyNeq;
  /**
   * 应付金额 比较(gt)
   */
  private java.math.BigDecimal shouldMoneyGt;
  /**
   * 应付金额 比较(gte)
   */
  private java.math.BigDecimal shouldMoneyGte;
  /**
   * 应付金额 比较(lt)
   */
  private java.math.BigDecimal shouldMoneyLt;
  /**
   * 应付金额 比较(lte)
   */
  private java.math.BigDecimal shouldMoneyLte;
  /**
   * 应付金额 比较(contains)
   */
  private java.math.BigDecimal shouldMoneyContains;
  /**
   * 应付金额 比较(notcontains)
   */
  private java.math.BigDecimal shouldMoneyNotcontains;
  /**
   * 应付金额 比较(startswith)
   */
  private java.math.BigDecimal shouldMoneyStartswith;
  /**
   * 应付金额 比较(endswith)
   */
  private java.math.BigDecimal shouldMoneyEndswith;
  /**
   * 应付金额 比较(isnull)
   */
  private Boolean shouldMoneyIsnull;
  /**
   * 应付金额 比较(isnotnull)
   */
  private Boolean shouldMoneyIsnotnull;

  /**
   * 已付金额
   */
  private java.math.BigDecimal actuallyPaid;

  /**
   * 最小已付金额
   */
  private java.math.BigDecimal actuallyPaidMin;

  /**
   * 最大已付金额
   */
  private java.math.BigDecimal actuallyPaidMax;

  /**
   * 已付金额 比较(eq)
   */
  private java.math.BigDecimal actuallyPaidEq;
  /**
   * 已付金额 比较(neq)
   */
  private java.math.BigDecimal actuallyPaidNeq;
  /**
   * 已付金额 比较(gt)
   */
  private java.math.BigDecimal actuallyPaidGt;
  /**
   * 已付金额 比较(gte)
   */
  private java.math.BigDecimal actuallyPaidGte;
  /**
   * 已付金额 比较(lt)
   */
  private java.math.BigDecimal actuallyPaidLt;
  /**
   * 已付金额 比较(lte)
   */
  private java.math.BigDecimal actuallyPaidLte;
  /**
   * 已付金额 比较(contains)
   */
  private java.math.BigDecimal actuallyPaidContains;
  /**
   * 已付金额 比较(notcontains)
   */
  private java.math.BigDecimal actuallyPaidNotcontains;
  /**
   * 已付金额 比较(startswith)
   */
  private java.math.BigDecimal actuallyPaidStartswith;
  /**
   * 已付金额 比较(endswith)
   */
  private java.math.BigDecimal actuallyPaidEndswith;
  /**
   * 已付金额 比较(isnull)
   */
  private Boolean actuallyPaidIsnull;
  /**
   * 已付金额 比较(isnotnull)
   */
  private Boolean actuallyPaidIsnotnull;

  /**
   * 未付金额
   */
  private java.math.BigDecimal unpaidMoney;

  /**
   * 最小未付金额
   */
  private java.math.BigDecimal unpaidMoneyMin;

  /**
   * 最大未付金额
   */
  private java.math.BigDecimal unpaidMoneyMax;

  /**
   * 未付金额 比较(eq)
   */
  private java.math.BigDecimal unpaidMoneyEq;
  /**
   * 未付金额 比较(neq)
   */
  private java.math.BigDecimal unpaidMoneyNeq;
  /**
   * 未付金额 比较(gt)
   */
  private java.math.BigDecimal unpaidMoneyGt;
  /**
   * 未付金额 比较(gte)
   */
  private java.math.BigDecimal unpaidMoneyGte;
  /**
   * 未付金额 比较(lt)
   */
  private java.math.BigDecimal unpaidMoneyLt;
  /**
   * 未付金额 比较(lte)
   */
  private java.math.BigDecimal unpaidMoneyLte;
  /**
   * 未付金额 比较(contains)
   */
  private java.math.BigDecimal unpaidMoneyContains;
  /**
   * 未付金额 比较(notcontains)
   */
  private java.math.BigDecimal unpaidMoneyNotcontains;
  /**
   * 未付金额 比较(startswith)
   */
  private java.math.BigDecimal unpaidMoneyStartswith;
  /**
   * 未付金额 比较(endswith)
   */
  private java.math.BigDecimal unpaidMoneyEndswith;
  /**
   * 未付金额 比较(isnull)
   */
  private Boolean unpaidMoneyIsnull;
  /**
   * 未付金额 比较(isnotnull)
   */
  private Boolean unpaidMoneyIsnotnull;

  /**
   * 申请中
   */
  private java.math.BigDecimal inApplication;

  /**
   * 最小申请中
   */
  private java.math.BigDecimal inApplicationMin;

  /**
   * 最大申请中
   */
  private java.math.BigDecimal inApplicationMax;

  /**
   * 申请中 比较(eq)
   */
  private java.math.BigDecimal inApplicationEq;
  /**
   * 申请中 比较(neq)
   */
  private java.math.BigDecimal inApplicationNeq;
  /**
   * 申请中 比较(gt)
   */
  private java.math.BigDecimal inApplicationGt;
  /**
   * 申请中 比较(gte)
   */
  private java.math.BigDecimal inApplicationGte;
  /**
   * 申请中 比较(lt)
   */
  private java.math.BigDecimal inApplicationLt;
  /**
   * 申请中 比较(lte)
   */
  private java.math.BigDecimal inApplicationLte;
  /**
   * 申请中 比较(contains)
   */
  private java.math.BigDecimal inApplicationContains;
  /**
   * 申请中 比较(notcontains)
   */
  private java.math.BigDecimal inApplicationNotcontains;
  /**
   * 申请中 比较(startswith)
   */
  private java.math.BigDecimal inApplicationStartswith;
  /**
   * 申请中 比较(endswith)
   */
  private java.math.BigDecimal inApplicationEndswith;
  /**
   * 申请中 比较(isnull)
   */
  private Boolean inApplicationIsnull;
  /**
   * 申请中 比较(isnotnull)
   */
  private Boolean inApplicationIsnotnull;

  /**
   * 未申请
   */
  private java.math.BigDecimal notApply;

  /**
   * 最小未申请
   */
  private java.math.BigDecimal notApplyMin;

  /**
   * 最大未申请
   */
  private java.math.BigDecimal notApplyMax;

  /**
   * 未申请 比较(eq)
   */
  private java.math.BigDecimal notApplyEq;
  /**
   * 未申请 比较(neq)
   */
  private java.math.BigDecimal notApplyNeq;
  /**
   * 未申请 比较(gt)
   */
  private java.math.BigDecimal notApplyGt;
  /**
   * 未申请 比较(gte)
   */
  private java.math.BigDecimal notApplyGte;
  /**
   * 未申请 比较(lt)
   */
  private java.math.BigDecimal notApplyLt;
  /**
   * 未申请 比较(lte)
   */
  private java.math.BigDecimal notApplyLte;
  /**
   * 未申请 比较(contains)
   */
  private java.math.BigDecimal notApplyContains;
  /**
   * 未申请 比较(notcontains)
   */
  private java.math.BigDecimal notApplyNotcontains;
  /**
   * 未申请 比较(startswith)
   */
  private java.math.BigDecimal notApplyStartswith;
  /**
   * 未申请 比较(endswith)
   */
  private java.math.BigDecimal notApplyEndswith;
  /**
   * 未申请 比较(isnull)
   */
  private Boolean notApplyIsnull;
  /**
   * 未申请 比较(isnotnull)
   */
  private Boolean notApplyIsnotnull;

  /**
   * 费用提交人
   */
  private Long feeSubmitter;

  /**
   * 费用提交人 比较(eq)
   */
  private Long feeSubmitterEq;
  /**
   * 费用提交人 比较(neq)
   */
  private Long feeSubmitterNeq;
  /**
   * 费用提交人 比较(gt)
   */
  private Long feeSubmitterGt;
  /**
   * 费用提交人 比较(gte)
   */
  private Long feeSubmitterGte;
  /**
   * 费用提交人 比较(lt)
   */
  private Long feeSubmitterLt;
  /**
   * 费用提交人 比较(lte)
   */
  private Long feeSubmitterLte;
  /**
   * 费用提交人 比较(contains)
   */
  private Long feeSubmitterContains;
  /**
   * 费用提交人 比较(notcontains)
   */
  private Long feeSubmitterNotcontains;
  /**
   * 费用提交人 比较(startswith)
   */
  private Long feeSubmitterStartswith;
  /**
   * 费用提交人 比较(endswith)
   */
  private Long feeSubmitterEndswith;
  /**
   * 费用提交人 比较(isnull)
   */
  private Boolean feeSubmitterIsnull;
  /**
   * 费用提交人 比较(isnotnull)
   */
  private Boolean feeSubmitterIsnotnull;
  /**
   * 费用提交人的显示用户名 比较(eq)
   */
  private String feeSubmitterNameEq;
  /**
   * 费用提交人的显示用户名 比较(neq)
   */
  private String feeSubmitterNameNeq;
  /**
   * 费用提交人的显示用户名 比较(gt)
   */
  private String feeSubmitterNameGt;
  /**
   * 费用提交人的显示用户名 比较(gte)
   */
  private String feeSubmitterNameGte;
  /**
   * 费用提交人的显示用户名 比较(lt)
   */
  private String feeSubmitterNameLt;
  /**
   * 费用提交人的显示用户名 比较(lte)
   */
  private String feeSubmitterNameLte;
  /**
   * 费用提交人的显示用户名 比较(contains)
   */
  private String feeSubmitterNameContains;
  /**
   * 费用提交人的显示用户名 比较(notcontains)
   */
  private String feeSubmitterNameNotcontains;
  /**
   * 费用提交人的显示用户名 比较(startswith)
   */
  private String feeSubmitterNameStartswith;
  /**
   * 费用提交人的显示用户名 比较(endswith)
   */
  private String feeSubmitterNameEndswith;
  /**
   * 费用提交人的显示用户名 比较(isnull)
   */
  private Boolean feeSubmitterNameIsnull;
  /**
   * 费用提交人的显示用户名 比较(isnotnull)
   */
  private Boolean feeSubmitterNameIsnotnull;

  /**
   * 费用提交人(范围搜索)
   */
  private List<Long> feeSubmitterInList;

  /**
   * 最早预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeStart;

  /**
   * 最晚预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeEnd;

  /**
   * 预计付款时间 比较(eq)
   */
  private Date predictFkTimeEq;
  /**
   * 预计付款时间 比较(neq)
   */
  private Date predictFkTimeNeq;
  /**
   * 预计付款时间 比较(gt)
   */
  private Date predictFkTimeGt;
  /**
   * 预计付款时间 比较(gte)
   */
  private Date predictFkTimeGte;
  /**
   * 预计付款时间 比较(lt)
   */
  private Date predictFkTimeLt;
  /**
   * 预计付款时间 比较(lte)
   */
  private Date predictFkTimeLte;
  /**
   * 预计付款时间 比较(contains)
   */
  private Date predictFkTimeContains;
  /**
   * 预计付款时间 比较(notcontains)
   */
  private Date predictFkTimeNotcontains;
  /**
   * 预计付款时间 比较(startswith)
   */
  private Date predictFkTimeStartswith;
  /**
   * 预计付款时间 比较(endswith)
   */
  private Date predictFkTimeEndswith;
  /**
   * 预计付款时间 比较(isnull)
   */
  private Boolean predictFkTimeIsnull;
  /**
   * 预计付款时间 比较(isnotnull)
   */
  private Boolean predictFkTimeIsnotnull;

  /**
   * 支付方式
   */
  private String payType;

  /**
   * 支付方式 比较(eq)
   */
  private String payTypeEq;
  /**
   * 支付方式 比较(neq)
   */
  private String payTypeNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String payTypeGt;
  /**
   * 支付方式 比较(gte)
   */
  private String payTypeGte;
  /**
   * 支付方式 比较(lt)
   */
  private String payTypeLt;
  /**
   * 支付方式 比较(lte)
   */
  private String payTypeLte;
  /**
   * 支付方式 比较(contains)
   */
  private String payTypeContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String payTypeNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String payTypeStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String payTypeEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean payTypeIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean payTypeIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> payTypeInList;

  /**
   * 户名(模糊搜索)
   */
  private String userName;

  /**
   * 户名 比较(eq)
   */
  private String userNameEq;
  /**
   * 户名 比较(neq)
   */
  private String userNameNeq;
  /**
   * 户名 比较(gt)
   */
  private String userNameGt;
  /**
   * 户名 比较(gte)
   */
  private String userNameGte;
  /**
   * 户名 比较(lt)
   */
  private String userNameLt;
  /**
   * 户名 比较(lte)
   */
  private String userNameLte;
  /**
   * 户名 比较(contains)
   */
  private String userNameContains;
  /**
   * 户名 比较(notcontains)
   */
  private String userNameNotcontains;
  /**
   * 户名 比较(startswith)
   */
  private String userNameStartswith;
  /**
   * 户名 比较(endswith)
   */
  private String userNameEndswith;
  /**
   * 户名 比较(isnull)
   */
  private Boolean userNameIsnull;
  /**
   * 户名 比较(isnotnull)
   */
  private Boolean userNameIsnotnull;

  /**
   * 户名(精确搜索)
   */
  private List<String> userNameInList;

  /**
   * 开户行(模糊搜索)
   */
  private String bankOfDeposit;

  /**
   * 开户行 比较(eq)
   */
  private String bankOfDepositEq;
  /**
   * 开户行 比较(neq)
   */
  private String bankOfDepositNeq;
  /**
   * 开户行 比较(gt)
   */
  private String bankOfDepositGt;
  /**
   * 开户行 比较(gte)
   */
  private String bankOfDepositGte;
  /**
   * 开户行 比较(lt)
   */
  private String bankOfDepositLt;
  /**
   * 开户行 比较(lte)
   */
  private String bankOfDepositLte;
  /**
   * 开户行 比较(contains)
   */
  private String bankOfDepositContains;
  /**
   * 开户行 比较(notcontains)
   */
  private String bankOfDepositNotcontains;
  /**
   * 开户行 比较(startswith)
   */
  private String bankOfDepositStartswith;
  /**
   * 开户行 比较(endswith)
   */
  private String bankOfDepositEndswith;
  /**
   * 开户行 比较(isnull)
   */
  private Boolean bankOfDepositIsnull;
  /**
   * 开户行 比较(isnotnull)
   */
  private Boolean bankOfDepositIsnotnull;

  /**
   * 开户行(精确搜索)
   */
  private List<String> bankOfDepositInList;

  /**
   * 账户(模糊搜索)
   */
  private String account;

  /**
   * 账户 比较(eq)
   */
  private String accountEq;
  /**
   * 账户 比较(neq)
   */
  private String accountNeq;
  /**
   * 账户 比较(gt)
   */
  private String accountGt;
  /**
   * 账户 比较(gte)
   */
  private String accountGte;
  /**
   * 账户 比较(lt)
   */
  private String accountLt;
  /**
   * 账户 比较(lte)
   */
  private String accountLte;
  /**
   * 账户 比较(contains)
   */
  private String accountContains;
  /**
   * 账户 比较(notcontains)
   */
  private String accountNotcontains;
  /**
   * 账户 比较(startswith)
   */
  private String accountStartswith;
  /**
   * 账户 比较(endswith)
   */
  private String accountEndswith;
  /**
   * 账户 比较(isnull)
   */
  private Boolean accountIsnull;
  /**
   * 账户 比较(isnotnull)
   */
  private Boolean accountIsnotnull;

  /**
   * 账户(精确搜索)
   */
  private List<String> accountInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
